package com.atguigu.gulimail.product.controller;

import java.util.*;
import java.util.stream.Collectors;

import com.atguigu.gulimail.product.entity.BrandEntity;
import com.atguigu.gulimail.product.vo.BrandVo;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import com.atguigu.gulimail.product.entity.CategoryBrandRelationEntity;
import com.atguigu.gulimail.product.service.CategoryBrandRelationService;
import com.atguigu.common.utils.PageUtils;
import com.atguigu.common.utils.R;


/**
 * 品牌分类关联
 * 多对多关系 ----->一个品牌可以属于多个分类，一个分类可以有多个品牌
 *
 * @author lizhihang
 * @email sunlightcs@gmail.com
 * @date 2021-12-19 17:04:17
 */
@RestController
@RequestMapping("product/categorybrandrelation")
public class CategoryBrandRelationController {
    @Autowired
    private CategoryBrandRelationService categoryBrandRelationService;

    /**
     * 逆向生成的 带分页的条件查询
     */
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params) {
        PageUtils page = categoryBrandRelationService.queryPage(params);
        return R.ok().put("page", page);
    }



    /**
     * 品牌管理
     * 获取当前品牌关联的所有分类列表
     * @param brandId 品牌ID（非路径参数）
     * @return
     */
    @GetMapping("/catelog/list")
    public R cateloglist(@RequestParam("brandId") Long brandId) {
        QueryWrapper<CategoryBrandRelationEntity> wrapper = new QueryWrapper<CategoryBrandRelationEntity>();
        wrapper.eq("brand_id", brandId);
        List<CategoryBrandRelationEntity> data = categoryBrandRelationService.list(wrapper);
        return R.ok().put("data", data);
    }


    /**
     * 这里的catId是前端发送请求过来的参数
     * 不是路径传参，使用requestParms
     *
     * @return
     *
     * 套路：
     * 1、controller：接受请求，和处理前端提交过来的数据
     * 把数据封装成业务层想要的数据，传递给业务层
     * 或者校验数据
     * 2、service接受controller传来的数据，进行业务处理
     * 3、controller接受service处理完的数据，封装成前端指定的vo
     */
    @GetMapping("/brands/list")
    public R relationBrandList(@RequestParam(value = "catId", required = true) Long catId) {
        //直接封装成BrandEntity，这样之后可以服用service中的方法
        //而在controller中自行封装成BrandVoList，前端需要的数据
        List<BrandEntity> vos = categoryBrandRelationService.getBrandByCatId(catId);
        //把BrandEntity封装成BrandVo
        List<BrandVo> collect = vos.stream().map(item -> {
            BrandVo brandVo = new BrandVo();
            brandVo.setBrandId(item.getBrandId());
            brandVo.setBrandName(item.getName());
            return brandVo;
        }).collect(Collectors.toList());
        //去除重复元素
        LinkedHashSet<BrandVo> hashSet = new LinkedHashSet<>(collect);
        ArrayList<BrandVo> listWithoutDuplicates = new ArrayList<>(hashSet);
        return R.ok().put("data",listWithoutDuplicates);
    }



    /**
     * 保存
     * 前端传过来的数据只是一个品牌ID和一个分类ID
     * 所以需要自己定义新的save方法
     * 设计brand-category关系表的时候设计了冗余字段，避免多次关联查询
     */
    @RequestMapping("/save")
    public R save(@RequestBody CategoryBrandRelationEntity categoryBrandRelation) {
        //categoryBrandRelationService.save(categoryBrandRelation);(原生的保存关联关系方法说)
        categoryBrandRelationService.saveDetail(categoryBrandRelation);
        return R.ok();
    }


    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id) {
        CategoryBrandRelationEntity categoryBrandRelation = categoryBrandRelationService.getById(id);
        return R.ok().put("categoryBrandRelation", categoryBrandRelation);
    }


    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody CategoryBrandRelationEntity categoryBrandRelation) {
        categoryBrandRelationService.updateById(categoryBrandRelation);
        return R.ok();
    }

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids) {
        categoryBrandRelationService.removeByIds(Arrays.asList(ids));

        return R.ok();
    }

}
